package com.magic.zhixin.handler.DelayTask;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class DelayTaskClient {
    Logger log = LoggerFactory.getLogger(DelayTaskClient.class);
    @Autowired
    private DelayTaskConsumer delayTaskConsumer;
    private static java.util.concurrent.DelayQueue queue = new java.util.concurrent.DelayQueue();


    /**直接添加到内存队列的，无需存数据库**/
//    private  void _addInitTask(Date initStartTime){
//        DelayTask delayTask = new DelayTask();
//        delayTask.setStarttime(initStartTime);
//        DelayedTask taskDelayed = new DelayedTask(DelayedTask.INIT_TASK, delayTask);
//        queue.add(taskDelayed);
//        log.info("成功添加一个延时队列初始化任务到内存队列，执行时间："+DateUtils.toString(initStartTime));
//    }

    /**
     * 添加定时任务到内存队列库
     * @param delayedTask
     */
    public   void  addDelayTask(DelayedTask delayedTask){
        if(!queue.contains(delayedTask)){
            queue.add(delayedTask);
        }
        log.info("=====成功添加类型为：{}的定时任务,其中执行时间为{}，bussinessId为：{}",
                delayedTask.getTaskType(),delayedTask.getExeDateTime(),delayedTask.getBussinessId());
    }




//    public void initAddTask(){
//        List<Bet> unfinishBetList =betMapper.findByEndPriceIsNull();
//        if (CollectionUtils.isEmpty(unfinishBetList)) {
//            log.info("没有未完成的下注定时任务");
//            return;
//        }
//        for (Bet bet : unfinishBetList) {
//            addDelayTask(bet);
//        }
//    }


    public void removeTask(DelayedTask delayedTask){
        if(queue.contains(delayedTask)){
            queue.remove(delayedTask);
        }
    }

    public void updateTaskExeTime(DelayedTask delayedTask){
        if(queue.contains(delayedTask)){
            queue.remove(delayedTask);
            queue.add(delayedTask);
            log.info("===定时任务修改成功 新的结束时间：" + delayedTask.getExeDateTime() );
        }
    }



    public void start(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                _start();
                log.info(Thread.currentThread().getName()+"==定时任务服务启动成功，启动时间："+ new Date());
            }
        }).start();
    }
    private   void _start(){
//        initAddTask();//添加初始化定时队列任务
        
        while (true){
            while(!queue.isEmpty()) {
                DelayedTask delayedTask= null;
                try {
                    delayedTask = (DelayedTask) queue.take();
//                    Integer taskType = delayedTask.getTaskType();
                    //时间到了驱动任务执行，如生产者将定时任务发到定时队列，实现异步，
                    // 而定时任务队列，不执行任务，只是实现定时驱动功能，时间到就将这个定时任务发回给任务生产者
                    //也就是说源头就是生产者也是消费者，定时任务队列，只是帮其定时的一个通用服务，不耦合业务，
                    //生产者通过http请求与定时任务队列通信，同时作为消费者，它也应该提供一个接收任务的接口。所有在发送任务的时候需要提供回调url，
                    //参数为DelayTask，或者startTime和data两个参数
                    //此处根据需要考虑线程池
                    delayTaskConsumer.consume(delayedTask);
                  log.info("=====成功执行类型为：{}的定时任务,其中执行时间为{}，bussinessId为：{}",
                            delayedTask.getTaskType(),delayedTask.getExeDateTime(),delayedTask.getBussinessId());
                } catch (InterruptedException e) {
                    log.error("消费定时任务出现未知错误，定时任务bussinessId为：{},原因为：{}",delayedTask.getBussinessId(),e.toString());
                    e.printStackTrace();
                }catch (Exception e) {
                    log.error("消费定时任务出错，定时任务bussinessId为：{},原因为：{}",delayedTask.getBussinessId(),e.toString());
                    e.printStackTrace();
                }
            }
            try {
                Thread.sleep(20*1000);
            } catch (InterruptedException e) {
                log.error(e.toString());
            }

        }
    }



}
